/**
 * 数据缓存管理器 - Phase 1 性能优化
 * 用于缓存数据转换结果，避免重复计算
 */

import { globalPerformanceMonitor } from './performance-monitor';

// 缓存条目接口
interface CacheEntry<T = any> {
  result: T;
  timestamp: number;
  hash: string; // 数据哈希，用于验证数据是否变化
}

// 缓存配置
interface CacheConfig {
  maxSize: number; // 最大缓存条目数
  ttl: number; // 缓存存活时间(ms)
  cleanupInterval: number; // 清理间隔(ms)
}

// 默认配置
const DEFAULT_CONFIG: CacheConfig = {
  maxSize: 1000, // 最大1000个条目
  ttl: 100, // 100ms缓存时间
  cleanupInterval: 10000 // 10s清理一次
};

/**
 * 简单哈希函数，用于生成数据指纹
 */
function simpleHash(data: any): string {
  const str = JSON.stringify(data);
  let hash = 0;
  for (let i = 0; i < str.length; i++) {
    const char = str.charCodeAt(i);
    hash = (hash << 5) - hash + char;
    hash = hash & hash; // 转换为32位整数
  }
  return hash.toString(36);
}

/**
 * 数据缓存管理器类
 */
export class DataCacheManager {
  private cache = new Map<string, CacheEntry>();
  private config: CacheConfig;
  private cleanupTimer: number | null = null;

  constructor(config: Partial<CacheConfig> = {}) {
    this.config = { ...DEFAULT_CONFIG, ...config };
    this.startCleanup();
  }

  /**
   * 获取缓存的转换结果
   * @param key 缓存键
   * @param data 原始数据
   * @param transformer 转换函数
   * @returns 转换结果
   */
  getTransformed<T>(key: string, data: any, transformer: (data: any) => T): T {
    const now = Date.now();
    const hash = simpleHash(data);
    const cacheKey = `${key}:${hash}`;

    // 检查缓存
    const cached = this.cache.get(cacheKey);
    if (cached && now - cached.timestamp < this.config.ttl) {
      globalPerformanceMonitor.recordCacheHit(cacheKey);
      return cached.result;
    }

    // 计算新结果
    globalPerformanceMonitor.recordCacheMiss(cacheKey);
    const result = transformer(data);

    // 存储到缓存
    this.set(cacheKey, result, hash);

    return result;
  }

  /**
   * 设置缓存条目
   */
  private set<T>(key: string, result: T, hash: string): void {
    // 检查缓存大小限制
    if (this.cache.size >= this.config.maxSize) {
      this.evictOldest();
    }

    this.cache.set(key, {
      result,
      timestamp: Date.now(),
      hash
    });
  }

  /**
   * 获取缓存条目
   */
  get<T>(key: string): T | null {
    const entry = this.cache.get(key);
    if (!entry) return null;

    const now = Date.now();
    if (now - entry.timestamp > this.config.ttl) {
      this.cache.delete(key);
      return null;
    }

    return entry.result;
  }

  /**
   * 删除缓存条目
   */
  delete(key: string): boolean {
    return this.cache.delete(key);
  }

  /**
   * 清空所有缓存
   */
  clear(): void {
    this.cache.clear();
  }

  /**
   * 获取缓存统计信息
   */
  getStats() {
    return {
      size: this.cache.size,
      maxSize: this.config.maxSize,
      ttl: this.config.ttl,
      hitRate: this.calculateHitRate()
    };
  }

  /**
   * 淘汰最老的缓存条目
   */
  private evictOldest(): void {
    let oldestKey: string | null = null;
    let oldestTime = Date.now();

    for (const [key, entry] of this.cache) {
      if (entry.timestamp < oldestTime) {
        oldestTime = entry.timestamp;
        oldestKey = key;
      }
    }

    if (oldestKey) {
      this.cache.delete(oldestKey);
    }
  }

  /**
   * 清理过期缓存
   */
  private cleanup(): void {
    const now = Date.now();
    const keysToDelete: string[] = [];

    for (const [key, entry] of this.cache) {
      if (now - entry.timestamp > this.config.ttl) {
        keysToDelete.push(key);
      }
    }

    keysToDelete.forEach((key) => this.cache.delete(key));
  }

  /**
   * 启动定期清理
   */
  private startCleanup(): void {
    if (this.cleanupTimer) {
      clearInterval(this.cleanupTimer);
    }

    this.cleanupTimer = window.setInterval(() => {
      this.cleanup();
    }, this.config.cleanupInterval);
  }

  /**
   * 停止定期清理
   */
  destroy(): void {
    if (this.cleanupTimer) {
      clearInterval(this.cleanupTimer);
      this.cleanupTimer = null;
    }
    this.clear();
  }

  /**
   * 计算缓存命中率 (简单实现)
   */
  private calculateHitRate(): number {
    // 这是一个简化实现，实际项目中可以维护更详细的统计
    return this.cache.size > 0 ? 0.8 : 0; // 假设80%命中率
  }
}

// 全局缓存实例
export const globalDataCache = new DataCacheManager({
  maxSize: 500, // 适度的缓存大小
  ttl: 100, // 100ms缓存时间窗口
  cleanupInterval: 15000 // 15s清理间隔
});

/**
 * 便捷的缓存转换函数
 */
export function getCachedTransform<T>(key: string, data: any, transformer: (data: any) => T): T {
  return globalDataCache.getTransformed(key, data, transformer);
}
